// 题目要求：
// 一条道路被分为 n 个部分，每个部分的黑暗值为 a[i]
// 妖怪每次能吞噬连续的 3 个路段，且只能获得中间路段的黑暗值作为饱腹值
// 问妖怪最多可以获得多少饱腹值？
// 3 <= n <= 100000

// 解题思路 1：
// 定义 dp[i] 表示 吞噬 [0, i] 路段，妖怪能获得的最大饱腹值
// 讨论最后 3 个路段：
// 如果不吞噬最后 3 个路段：dp[i] = dp[i - 1]
// 如果吞噬最后 3 个路段：dp[i] = dp[i - 3] + a[i - 1]
// 上面两种情况，求取最大值即可

// 解题思路 2：
// 定义 f[i] 表示吞噬最后 3 个路段能获得的最大饱腹值
// 定义 g[i] 表示不吞噬最后 3 个路段能获得的最大饱腹值
// f[i] = max(f[i - 3], g[i - 3])
// g[i] = max(f[i - 1], g[i - 1])
// 最终返回 max(f[n - 1], g[n - 1]) 即可

import java.util.*;


public class TheDarkMonster {
    // 解题思路 1：
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        int[] a = new int[n];

        for(int i = 0; i < n; i++){
            a[i] = in.nextInt();
        }

        long[] dp = new long[n];
        dp[0] = dp[1] = 0;
        dp[2] = a[1];

        for(int i = 3; i < n; i++){
            dp[i] = dp[i - 1];
            if(i - 3 >= 0){
                dp[i] = Math.max(dp[i], dp[i - 3] + a[i - 1]);
            }
        }


        System.out.println(dp[n - 1]);
    }

    // 解题思路 2：
    public static void main2(String[] args){
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        int[] a = new int[n];

        for(int i = 0; i < n; i++){
            a[i] = in.nextInt();
        }

        long[] f = new long[n];
        long[] g = new long[n];

        f[0] = f[1] = 0;
        f[2] = a[1];

        g[0] = g[1] = g[2] = 0;

        for(int i = 3; i < n; i++){
            f[i] = Math.max(f[i - 3], g[i - 3]) + a[i - 1];
            g[i] = Math.max(f[i - 1], g[i - 1]);
        }

        System.out.println(Math.max(f[n - 1], g[n - 1]));
    }
}

